home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / clang / jcool01.zip / BASE_STA.C < prev    next >
C/C++ Source or Header  |  1992-09-23  |  8KB  |  216 lines
  1. //
  2. // Copyright (C) 1991 Texas Instruments Incorporated.
  3. //
  4. // Permission is granted to any individual or institution to use, copy, modify,
  5. // and distribute this software, provided that this complete copyright and
  6. // permission notice is maintained, intact, in all copies and supporting
  7. // documentation.
  8. //
  9. // Texas Instruments Incorporated provides this software "as is" without
  10. // express or implied warranty.
  11. //
  12. // Created: MBN 08/29/89 -- Initial design and implementation
  13. // Updated: MJF 03/12/90 -- Added group names to RAISE
  14. // Updated: JAM 09/23/92 -- added def for alloc_size_s and initialized
  15. //
  16. // The CoolStack class is  publicly  derived from the  Generic class and is used to
  17. // implement non-type specific functionality for the parameterized CoolStack class.
  18. // In  this manner, code common  to  all instances  of the  CoolStack  class can be
  19. // shared to reduce code replication.  The  CoolStack class  implements a one
  20. // dimensional vector of a user-specified type.  This  is accomplished by using
  21. // the parameterized type  capability of C++.  The  stack will grow dynamically
  22. // as necessary  with   the amount  of  growth determined  by  the value  of an
  23. // allocation size slot.  Fixed length stacks are also supported by setting the
  24. // value of the allocation size slot to zero.
  25. //
  26.  
  27. #ifndef BASE_STACKH                // If no definition for CoolStack
  28. #include <cool/Base_Stack.h>            // Include definition file
  29. #endif
  30.  
  31. // int alloc_size_s -- Allocation size for growth
  32. int CoolBase_Stack::alloc_size_s = STACK_MEM_BLK_SZ;
  33.  
  34. // long set_length(long, char*) -- Change number of elements in this stack
  35. // Input:                          Integer number of elements and
  36. //                                 character string of type
  37. // Output:                         Number of elements
  38.  
  39. long CoolBase_Stack::set_length (long n, const char* Type) {
  40. #if ERROR_CHECKING
  41.   if (n < 0) {                    // If index out of range
  42.     //RAISE (Error, SYM(CoolStack), SYM(Negative_Length),
  43.     printf ("CoolStack<%s>::set_length(): Negative length %d.\n", Type, n);
  44.     abort ();
  45.   }
  46. #endif
  47.   if (n <= size)                // If not greater than size
  48.     this->number_elements = n;            // Set new length
  49.   else
  50.     this->number_elements = size;        // Else set to maximum possible
  51.   return this->number_elements;            // Return value
  52. }
  53.  
  54.  
  55. // void set_growth_ratio(float, char*) -- Set growth percentage of this stack
  56. // Input:                                 Float ratio and character string type
  57. // Output:                                None
  58.  
  59. void CoolBase_Stack::set_growth_ratio (float ratio, const char* Type) {
  60. #if ERROR_CHECKING
  61.   if (ratio <= 0.0) {                // If non-positive growth
  62.     //RAISE (Error, SYM(CoolStack), SYM(Negative_Ratio),
  63.     printf ("CoolStack<%s>::set_growth_ratio(): Negative growth ratio %f.\n",
  64.         Type, ratio);
  65.     abort ();
  66.   }
  67. #endif
  68.   this->growth_ratio = ratio;            // Adjust instance ration
  69. } 
  70.  
  71.  
  72. // void set_alloc_size(int, char*) -- Set the default allocation size 
  73. // Input:                             Integer size and character string type
  74. // Output:                            None
  75.  
  76. void CoolBase_Stack::set_alloc_size (int size, const char* Type) {
  77. #if ERROR_CHECKING
  78.   if (size < 0) {                    // If index out of range
  79.     //RAISE (Error, SYM(CoolStack), SYM(Negative_Size),
  80.     printf ("CoolStack<%s>::set_alloc_size(): Negative growth size %d.\n",
  81.         Type, size);
  82.     abort ();
  83.   }
  84. #endif
  85.   this->alloc_size_s = size;            // Set growth size
  86. }
  87.  
  88.  
  89. // CoolBase_Stack () -- Empty constructor for the CoolBase_Stack class
  90. // Input:            None
  91. // Output:           None
  92.  
  93. CoolBase_Stack::CoolBase_Stack () {
  94.   this->size = 0;                // Initialize size
  95.   this->number_elements = 0;            // Initialize element count
  96.   this->growth_ratio = 0.0;            // Intialize growth ratio
  97. }
  98.  
  99.  
  100. // CoolBase_Stack (long) -- constructor that specifies number of elements
  101. // Input:          Integer number of elements
  102. // Output:         None
  103.  
  104. CoolBase_Stack::CoolBase_Stack (long n) {
  105.   this->size = n;                // Element capacity
  106.   this->number_elements = 0;            // No elements
  107.   this->growth_ratio = 0.0;            // Initialize growth ratio 
  108. }
  109.  
  110.  
  111. // CoolBase_Stack (CoolBase_Stack&) -- constructor for reference to another stack
  112. // Input:                        CoolBase_Stack reference
  113. // Output:                       None
  114.  
  115. CoolBase_Stack::CoolBase_Stack (const CoolBase_Stack& s) {
  116.   this->growth_ratio = s.growth_ratio;        // New growth ratio
  117.   this->size = s.size;                // New size
  118.   this->number_elements = s.number_elements;    // New number of elements
  119. }
  120.  
  121.  
  122. // ~CoolBase_Stack -- Destructor for CoolBase_Stack class that frees up storage
  123. // Input:          None
  124. // Output:         None
  125.  
  126. CoolBase_Stack::~CoolBase_Stack () {
  127. }
  128.  
  129.  
  130. // CoolBase_Stack& operator= (CoolBase_Stack&) -- Assigns this stack to another stack
  131. // Input:                       Reference to a stack
  132. // Output:                      Reference to modified this
  133.  
  134. CoolBase_Stack& CoolBase_Stack::operator= (const CoolBase_Stack& s) {
  135.   this->number_elements = s.number_elements;    // New number of elements
  136.   this->growth_ratio = s.growth_ratio;          // New growth ratio
  137.   return *this;                    // Return reference
  138. }
  139.  
  140.  
  141. // assign_error -- Error message for parameterized CoolBase_Stack<Type>::operator=()
  142. // Input:          Character string of type
  143. // Output:         None
  144.  
  145. void CoolBase_Stack::assign_error (const char* Type) {
  146.   //RAISE (Error, SYM(CoolStack), SYM(Static_Size),
  147.   printf ("CoolStack<%s>::operator=(): Static-size stack.\n", Type);
  148.   abort ();
  149. }
  150.  
  151.  
  152. // top_error -- Error message for parameterized CoolStack<Type>::top()
  153. // Input:       Character string of type
  154. // Output:      None
  155.  
  156. void CoolBase_Stack::top_error (const char* Type) {
  157.   //RAISE (Error, SYM(CoolStack), SYM(No_Elements),
  158.   printf ("CoolStack<%s>::top(): No elements in stack.\n", Type);
  159.   abort ();
  160. }
  161.  
  162.  
  163. // pop_error -- Error message for parameterized CoolStack<Type>::pop()
  164. // Input:       Character string of type
  165. // Output:      None
  166.  
  167. void CoolBase_Stack::pop_error (const char* Type) {
  168.   //RAISE (Error, SYM(CoolStack), SYM(No_Elements),
  169.   printf ("CoolStack<%s>::pop(): No elements in stack.\n", Type);
  170.   abort ();
  171. }
  172.  
  173.  
  174. // bracket_error -- Error message for parameterized CoolStack<Type>::operator[]()
  175. // Input:           Character string of type and index
  176. // Output:          None
  177.  
  178. void CoolBase_Stack::bracket_error (const char* Type, long n) {
  179.   //RAISE (Error, SYM(CoolStack), SYM(Out_Of_Range),
  180.   printf ("CoolStack<%s>::operator[](): Index %d out of range.\n", Type, n);
  181.   abort ();
  182. }
  183.  
  184.  
  185. // push_error -- Error message for parameterized CoolStack<Type>::push()
  186. // Input:        Character string of type
  187. // Output:       None
  188.  
  189. void CoolBase_Stack::push_error (const char* Type) {
  190.   //RAISE (Error, SYM(CoolStack), SYM(Static_Size),
  191.   printf ("CoolStack<%s>::push(): Static-size stack.\n", Type);
  192.   abort ();
  193. }
  194.  
  195.  
  196. // popn_error -- Error message for parameterized CoolStack<Type>::popn()
  197. // Input:        Character string of type and index
  198. // Output:       None
  199.  
  200. void CoolBase_Stack::popn_error (const char* Type, long n) {
  201.   //RAISE (Error, SYM(CoolStack), SYM(Static_Size),
  202.   printf ("CoolStack<%s>::popn(): Negative stack index %d.\n", Type, n);
  203.   abort ();
  204. }
  205.  
  206.  
  207. // resize_error -- Error message for parameterized CoolStack<Type>::resize()
  208. // Input:          Character string of type and size
  209. // Output:         None
  210.  
  211. void CoolBase_Stack::resize_error (const char* Type, long new_size) {
  212.   //RAISE (Error, SYM(CoolStack), SYM(Negative_Size),
  213.   printf ("CoolStack<%s>::resize(): Negative resize %d.\n", Type, new_size);
  214.   abort ();
  215. }
  216.